\hypertarget{class_map}{}\section{Map Class Reference}
\label{class_map}\index{Map@{Map}}
Inheritance diagram for Map\+:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[height=2.000000cm]{class_map}
\end{center}
\end{figure}
\subsection*{Public Member Functions}
\begin{DoxyCompactItemize}
\item 
\hyperlink{class_map_a0f5ad0fd4563497b4214038cbca8b582}{Map} ()
\item 
virtual \hyperlink{class_map_aa403fbe09394ccf39747588f5168e3b2}{$\sim$\+Map} ()
\item 
{\footnotesize template$<$class scheduler  = simple\+\_\+schedule, class allocator  = dynalloc, class parallelism\+\_\+monitor  = basic\+\_\+parallel$>$ }\\void \hyperlink{class_map_ad875bad2283446bfeed2f69752984c2d}{exe} ()
\end{DoxyCompactItemize}
\subsection*{Protected Member Functions}
\begin{DoxyCompactItemize}
\item 
void \hyperlink{class_map_adcaba5f11ec1b7fef29a0a1e62632373}{check\+Edges} (kernelkeeper \&source\+\_\+k)
\item 
void \hyperlink{class_map_aa8673192361b2e519e1c85bb0935e708}{enable\+Duplication} (kernelkeeper \&source, kernelkeeper \&all)
\end{DoxyCompactItemize}
\subsection*{Friends}
\begin{DoxyCompactItemize}
\item 
class \hyperlink{class_map_a901ac6fe1c35f3c114cf9e83f75dde0c}{basic\+\_\+parallel}
\item 
\hypertarget{class_map_aae5808dc2e987bf17ef42196457a654d}{}class {\bfseries Schedule}\label{class_map_aae5808dc2e987bf17ef42196457a654d}

\item 
\hypertarget{class_map_a64fd97b135f77d4b136e8fff9a1c1ae1}{}class {\bfseries Allocate}\label{class_map_a64fd97b135f77d4b136e8fff9a1c1ae1}

\end{DoxyCompactItemize}
\subsection*{Additional Inherited Members}


\subsection{Constructor \& Destructor Documentation}
\hypertarget{class_map_a0f5ad0fd4563497b4214038cbca8b582}{}\index{Map@{Map}!Map@{Map}}
\index{Map@{Map}!Map@{Map}}
\subsubsection[{Map()}]{\setlength{\rightskip}{0pt plus 5cm}Map\+::\+Map (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{class_map_a0f5ad0fd4563497b4214038cbca8b582}
\hyperlink{class_map}{Map} -\/ constructor, really doesn\textquotesingle{}t do too much at the monent and doesn\textquotesingle{}t really need to.

map.\+cpp -\/ \begin{DoxyAuthor}{Author}
\+: Jonathan Beard 
\end{DoxyAuthor}
\begin{DoxyVersion}{Version}
\+: Fri Sep 12 10\+:28\+:33 2014
\end{DoxyVersion}
Copyright 2014 Jonathan Beard

Licensed under the Apache License, Version 2.\+0 (the \char`\"{}\+License\char`\"{}); you may not use this file except in compliance with the License. You may obtain a copy of the License at\+:

\href{http://www.apache.org/licenses/LICENSE-2.0}{\tt http\+://www.\+apache.\+org/licenses/\+L\+I\+C\+E\+N\+S\+E-\/2.\+0}

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an \char`\"{}\+A\+S I\+S\char`\"{} B\+A\+S\+I\+S, W\+I\+T\+H\+O\+U\+T W\+A\+R\+R\+A\+N\+T\+I\+E\+S O\+R C\+O\+N\+D\+I\+T\+I\+O\+N\+S O\+F A\+N\+Y K\+I\+N\+D, either express or implied. See the License for the specific language governing permissions and limitations under the License. \hypertarget{class_map_aa403fbe09394ccf39747588f5168e3b2}{}\index{Map@{Map}!````~Map@{$\sim$\+Map}}
\index{````~Map@{$\sim$\+Map}!Map@{Map}}
\subsubsection[{$\sim$\+Map()}]{\setlength{\rightskip}{0pt plus 5cm}Map\+::$\sim$\+Map (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [virtual]}}\label{class_map_aa403fbe09394ccf39747588f5168e3b2}
default destructor 

\subsection{Member Function Documentation}
\hypertarget{class_map_adcaba5f11ec1b7fef29a0a1e62632373}{}\index{Map@{Map}!check\+Edges@{check\+Edges}}
\index{check\+Edges@{check\+Edges}!Map@{Map}}
\subsubsection[{check\+Edges(kernelkeeper \&source\+\_\+k)}]{\setlength{\rightskip}{0pt plus 5cm}void Map\+::check\+Edges (
\begin{DoxyParamCaption}
\item[{kernelkeeper \&}]{source\+\_\+k}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [protected]}}\label{class_map_adcaba5f11ec1b7fef29a0a1e62632373}
check\+Edges -\/ runs a breadth first search through the graph to look for disconnected edges. 
\begin{DoxyParams}{Parameters}
{\em source\+\_\+k} & -\/ std\+::set$<$ raft\+::kernel$\ast$ $>$ \\
\hline
\end{DoxyParams}

\begin{DoxyExceptions}{Exceptions}
{\em \hyperlink{class_port_exception}{Port\+Exception}} & -\/ thrown if an unconnected edge is found. \\
\hline
\end{DoxyExceptions}
N\+O\+T\+E\+: will throw an error that we\textquotesingle{}re not catching here if there are unconnected edges...this is something that a user will have to fix. Otherwise will return with no errors.\hypertarget{class_map_aa8673192361b2e519e1c85bb0935e708}{}\index{Map@{Map}!enable\+Duplication@{enable\+Duplication}}
\index{enable\+Duplication@{enable\+Duplication}!Map@{Map}}
\subsubsection[{enable\+Duplication(kernelkeeper \&source, kernelkeeper \&all)}]{\setlength{\rightskip}{0pt plus 5cm}void Map\+::enable\+Duplication (
\begin{DoxyParamCaption}
\item[{kernelkeeper \&}]{source, }
\item[{kernelkeeper \&}]{all}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [protected]}}\label{class_map_aa8673192361b2e519e1c85bb0935e708}
enable\+Duplication -\/ add split / join kernels where needed, for the moment we\textquotesingle{}re going with a simple split/join topology, however that doesn\textquotesingle{}t mean that more complex topologies might not be implemented in the future. 
\begin{DoxyParams}{Parameters}
{\em source\+\_\+k} & -\/ std\+::set$<$ raft\+::kernel$\ast$ $>$ with sources\\
\hline
\end{DoxyParams}
void insert( \hyperlink{classraft_1_1kernel}{raft\+::kernel} \&a, \hyperlink{struct_port_info}{Port\+Info} \&a\+\_\+out, \hyperlink{classraft_1_1kernel}{raft\+::kernel} \&b, \hyperlink{struct_port_info}{Port\+Info} \&b\+\_\+in, \hyperlink{classraft_1_1kernel}{raft\+::kernel} \&i, \hyperlink{struct_port_info}{Port\+Info} \&i\+\_\+in, \hyperlink{struct_port_info}{Port\+Info} \&i\+\_\+out ); don\textquotesingle{}t have to do this but it makes it far more apparent where it comes from

need to grab impl of Lengauer and Tarjan dominators, use for S\+E\+S\+E

in the interim, restrict to kernels that are simple to duplicate

case of inline kernel

front -\/$>$ kernel\+\_\+a goes to front -\/$>$ split -\/$>$ kernel\+\_\+a

now we need the port info from the input port on back

kernel\+\_\+a -\/$>$ back goes to kernel\+\_\+a -\/$>$ join -\/$>$ back

finally set the flag to the scheduler so that the parallel map manager can pick it up an use it.

parallalizable source, single output no inputs

parallelizable sink, single input, no outputs

flag as candidate if the connecting kernel only has one input port.

simply flag as a candidate \hypertarget{class_map_ad875bad2283446bfeed2f69752984c2d}{}\index{Map@{Map}!exe@{exe}}
\index{exe@{exe}!Map@{Map}}
\subsubsection[{exe()}]{\setlength{\rightskip}{0pt plus 5cm}template$<$class scheduler  = simple\+\_\+schedule, class allocator  = dynalloc, class parallelism\+\_\+monitor  = basic\+\_\+parallel$>$ void Map\+::exe (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily [inline]}}\label{class_map_ad875bad2283446bfeed2f69752984c2d}
F\+I\+X\+M\+E, the graph tools need to take more than function, we\textquotesingle{}re wasting time by traversing the graph twice....will take awhile with big graphs. check types, ensure all are linked

adds in split/join kernels

launch allocator in a thread

launch scheduler in thread

launch parallelism monitor

ref to this

allocator

scheduler

exit parameter

join scheduler first

scheduler done, cleanup alloc

no more need to duplicate kernels

all fifo\textquotesingle{}s deallocated when alloc goes out of scope 

\subsection{Friends And Related Function Documentation}
\hypertarget{class_map_a901ac6fe1c35f3c114cf9e83f75dde0c}{}\index{Map@{Map}!basic\+\_\+parallel@{basic\+\_\+parallel}}
\index{basic\+\_\+parallel@{basic\+\_\+parallel}!Map@{Map}}
\subsubsection[{basic\+\_\+parallel}]{\setlength{\rightskip}{0pt plus 5cm}friend class {\bf basic\+\_\+parallel}\hspace{0.3cm}{\ttfamily [friend]}}\label{class_map_a901ac6fe1c35f3c114cf9e83f75dde0c}
T\+O\+D\+O, refactor \hyperlink{classbasic__parallel}{basic\+\_\+parallel} base class to match the all caps base class coding style 

The documentation for this class was generated from the following files\+:\begin{DoxyCompactItemize}
\item 
map.\+hpp\item 
map.\+cpp\end{DoxyCompactItemize}
